#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
构建脚本
用于编译整个项目或指定目标
"""

import os
import sys
import argparse
import subprocess
import time
from pathlib import Path

class ProjectBuilder:
    """
    项目构建器类
    """
    
    def __init__(self):
        """
        初始化构建器
        """
        self.build_tools_dir = Path(__file__).parent.resolve()
        self.project_root = None
        
    def validate_environment(self):
        """
        验证构建环境变量
        
        Raises:
            SystemExit: 当必需的环境变量不存在或无效时
        """
        required_vars = {
            'BUILD_PROJECT_ROOT': '项目根目录',
        }
        
        # FEATURE_CONFIG是可选的
        optional_vars = {
            'PROJECT_FEATURE_CONFIG': '特性配置文件',
            'PROJECT_BUILD_CONFIG': '项目配置文件'
        }
        
        # 验证必需的环境变量
        for var_name, description in required_vars.items():
            if var_name not in os.environ:
                print(f"[ERROR] 环境变量 {var_name} 未设置 ({description})")
                sys.exit(1)
            
            var_path = Path(os.environ[var_name])
            if not var_path.exists():
                print(f"[ERROR] {description} 不存在: {var_path}")
                sys.exit(1)
        
        # 验证可选的环境变量
        for var_name, description in optional_vars.items():
            if var_name in os.environ:
                var_path = Path(os.environ[var_name])
                if not var_path.exists():
                    print(f"[WARNING] {description} 不存在: {var_path}")
                    # 移除无效的环境变量
                    del os.environ[var_name]
                else:
                    print(f"[INFO] 找到可选配置: {description}")
        
        self.project_root = Path(os.environ['BUILD_PROJECT_ROOT'])
        print("[INFO] 环境变量验证通过")
        
    def validate_build_tools(self):
        """
        验证构建工具
        
        Raises:
            SystemExit: 当构建工具不存在时
        """
        if not self.build_tools_dir.exists():
            print(f"[ERROR] Build tools directory not found: {self.build_tools_dir}")
            sys.exit(1)
        
        scons_file = self.build_tools_dir / 'SConstruct'
        if not scons_file.exists():
            print(f"[ERROR] SConstruct file not found: {scons_file}")
            sys.exit(1)
        
        print("[INFO] 构建工具验证通过")
        
    def build_project(self, target=None, clean=False, extra_args=None):
        """
        构建项目
        
        Args:
            target: 构建目标（可选）
            clean: 是否清理模式
            extra_args: 额外参数列表
            
        Returns:
            int: 构建结果（0表示成功）
        """
        # 验证环境变量
        self.validate_environment()
        
        # 验证构建工具
        self.validate_build_tools()
        
        # 切换到项目根目录
        os.chdir(self.project_root)
    
        # 构建scons命令
        cmd = ['scons', '-f', str(self.build_tools_dir / 'SConstruct')]
        
        if clean:
            cmd.append('-c')
            print("[CLEAN] Starting clean...")
        else:
            if target:
                cmd.extend(['--target', target])
                print(f"[BUILD] Starting build for target: {target}...")
            else:
                print("[BUILD] Starting project build...")
        
        # 添加额外参数
        if extra_args:
            cmd.extend(extra_args)
        
        # 记录开始时间
        start_time = time.time()
        
        # 执行构建命令
        try:
            result = subprocess.run(cmd, check=False)
            
            if result.returncode != 0:
                print("[FAILED] Build failed!")
                return result.returncode
            
            # 计算构建时间
            build_time = time.time() - start_time
            print(f"[SUCCESS] Build completed in {build_time:.2f} seconds")
            return 0
            
        except FileNotFoundError:
            print("[ERROR] scons command not found. Please install SCons.")
            return 1
        except Exception as e:
            print(f"[ERROR] Build failed with exception: {e}")
            return 1

def main():
    """
    主函数
    """
    parser = argparse.ArgumentParser(
        description='项目构建脚本',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  %(prog)s                    # 构建整个项目
  %(prog)s ut_test           # 构建指定目标
  %(prog)s --target ut_test  # 构建指定目标（显式指定）
  %(prog)s --clean           # 清理构建
  %(prog)s -c                # 清理构建（简写）
        """
    )
    
    parser.add_argument(
        'target',
        nargs='?',
        help='构建目标名称（可选）'
    )
    
    parser.add_argument(
        '--target',
        dest='explicit_target',
        help='显式指定构建目标'
    )
    
    parser.add_argument(
        '-c', '--clean',
        action='store_true',
        help='清理构建'
    )
    
    parser.add_argument(
        '--project-root',
        type=Path,
        help='项目根目录（默认为脚本所在目录的上级目录）'
    )
    
    # 解析已知参数，剩余参数传递给scons
    args, unknown_args = parser.parse_known_args()
    
    # 确定构建目标
    target = args.explicit_target or args.target
    
    # 创建构建器并执行构建
    builder = ProjectBuilder()
    return builder.build_project(
        target=target,
        clean=args.clean,
        extra_args=unknown_args
    )

if __name__ == '__main__':
    sys.exit(main())